analyze_dataset(results_df)

analyze_dataset(goalscorers_df)

analyze_dataset(shootouts_df)

print("\nSummary Statistics - Results:")
print(results_df.describe())
missing_values_count = results_df.isnull().sum()
plt.figure(figsize=(10,6))
sns.barplot(x=missing_values_count.index, y=missing_values_count.values, palette="Reds")
plt.title('Count of missing data by features')
plt.ylabel('Count of missing values')
plt.xlabel('Features')
plt.xticks(rotation='vertical')
plt.show()

# Python cell
na_scores_df = results_df[results_df['home_score'].isnull() & results_df['away_score'].isnull()& results_df['away_team'].isnull()]
na_scores_df.head()

# Python modified cell
print("\nSummary Statistics - Shootouts:")
print(shootouts_df.describe())
missing_values_count = shootouts_df.isnull().sum()
plt.figure(figsize=(10,6))
sns.barplot(x=missing_values_count.index, y=missing_values_count.values, palette="Reds")
plt.title('Count of missing data in Shootouts by features')
plt.ylabel('Count of missing values')
plt.xlabel('Features')
plt.xticks(rotation='vertical')
plt.show()

print("\nSummary Statistics - Goalscorers:")
print(goalscorers_df.describe())
missing_values_count = goalscorers_df.isnull().sum()
plt.figure(figsize=(10,6))
sns.barplot(x=missing_values_count.index, y=missing_values_count.values, palette="tab10")
plt.title('Count of missing data in Goalscorers by features')
plt.ylabel('Count of missing values')
plt.xlabel('Features')
plt.xticks(rotation='vertical')
plt.show()

import matplotlib.pyplot as plt
# Calculate goals per year
goalscorers_df['date'] = pd.to_datetime(goalscorers_df['date'])
goalscorers_df['year'] = goalscorers_df['date'].dt.year
goals_per_year = goalscorers_df.groupby('year').size()

# Calculate shootouts per year
shootouts_df['date'] = pd.to_datetime(shootouts_df['date'])
shootouts_df['year'] = shootouts_df['date'].dt.year
shootouts_per_year = shootouts_df.groupby('year').size()


# Plotting the data with 2 rows and 2 columns layout
fig, axes = plt.subplots(2, 2, figsize=(16, 12))

# Goals per year
axes[0, 0].plot(goals_per_year.index, goals_per_year.values, label='Goals per Year', color='b')
axes[0, 0].set_title('Goals per Year')
axes[0, 0].set_xlabel('Year')
axes[0, 0].set_ylabel('Number of Goals')
axes[0, 0].legend()

# Shootouts per year
axes[0, 1].plot(shootouts_per_year.index, shootouts_per_year.values, label='Shootouts per Year', color='r')
axes[0, 1].set_title('Shootouts per Year')
axes[0, 1].set_xlabel('Year')
axes[0, 1].set_ylabel('Number of Shootouts')
axes[0, 1].legend()

# Distribution of Goals Scored by Home Teams
axes[1, 0].hist(results_df['home_score'], bins=20, color='blue', edgecolor='black')
axes[1, 0].set_title('Distribution of Goals Scored by Home Teams')
axes[1, 0].set_xlabel('Goals Scored')
axes[1, 0].set_ylabel('Frequency')

# Distribution of Goals Scored by Away Teams
axes[1, 1].hist(results_df['away_score'], bins=20, color='red', edgecolor='black')
axes[1, 1].set_title('Distribution of Goals Scored by Away Teams')
axes[1, 1].set_xlabel('Goals Scored')
axes[1, 1].set_ylabel('Frequency')

plt.tight_layout()
plt.show()

# Determine if the game took place in the home team's country
results_df['game_in_home_country'] = results_df['country'] == results_df['home_team']

# Determine if the home team won
results_df['home_team_won'] = results_df['home_score'] > results_df['away_score']

# Calculate the win/loss ratio for home games in home country vs not in home country
home_country_wins = results_df.groupby(['game_in_home_country', 'home_team_won']).size().unstack().fillna(0)
home_country_wins_ratio = home_country_wins.div(home_country_wins.sum(axis=1), axis=0)

# Create the plots side by side
fig, ax = plt.subplots(1, 2, figsize=(20, 8))

# Plot the win/loss ratio for home games in home country vs not in home country
home_country_wins_ratio.plot(kind='bar', stacked=True, color=['red', 'green'], ax=ax[0])
ax[0].set_title('Win/Loss Ratio for Home Games in Home Country vs Not')
ax[0].set_xlabel('Game in Home Country')
ax[0].set_ylabel('Ratio')
ax[0].set_xticks([0, 1])
ax[0].set_xticklabels(['No', 'Yes'], rotation=0)
ax[0].legend(['Loss', 'Win'], title='Home Team Outcome')

# Count the number of wins for home and away teams in neutral games
neutral_games = results_df[results_df['neutral'] == True]
neutral_games_wins = neutral_games.groupby(['home_team_won']).size().reset_index(name='count')
neutral_games_wins['team'] = ['Away Team Wins', 'Home Team Wins']

sns.barplot(data=neutral_games_wins, x='team', y='count', palette=['blue', 'orange'], ax=ax[1])
ax[1].set_title('Count of Wins in Neutral Games for Home and Away Teams')
ax[1].set_xlabel('Winning Team')
ax[1].set_ylabel('Count')

plt.tight_layout()
plt.show()

# Extract top 20 scorers from the goalscorers dataset
top_scorers_20 = goalscorers_df.groupby(['scorer', 'team']).size().reset_index(name='goals').sort_values(by='goals', ascending=False).head(20)

# Plot the top 20 scorers
plt.figure(figsize=(14, 10))
sns.barplot(data=top_scorers_20, x='goals', y='scorer', hue='team', dodge=False)
plt.title('Top 20 Scorers and Their Teams')
plt.xlabel('Goals')
plt.ylabel('Scorer')
plt.legend(title='Team', bbox_to_anchor=(1.05, 1), loc='upper left')
plt.show()

# Calculate total goals scored by each team as home team
home_goals = results_df.groupby('home_team')['home_score'].sum()

# Calculate total goals scored by each team as away team
away_goals = results_df.groupby('away_team')['away_score'].sum()

# Combine the totals for home and away games
total_goals = home_goals.add(away_goals, fill_value=0)

# Convert Series to DataFrame
total_goals_df = total_goals.reset_index()
total_goals_df.columns = ['team', 'total_goals']

# Display the result
total_goals_df

# Update total_goals_df
total_goals_df = total_goals_df.sort_values(by='total_goals', ascending=False)

# Selecting top 50 teams
top_50_teams_df = total_goals_df.head(50)

# Plotting the bar chart
plt.figure(figsize=(10,15))
sns.barplot(x='total_goals', y='team', data=top_50_teams_df)
plt.xlabel('Total Goals')
plt.ylabel('Team')
plt.title('Top 50 Teams and Their Total Goals')
plt.show()

# Count the number of different labels in the 'tournament' column
unique_tournament_labels = results_df['tournament'].nunique()
print('tournament labels count:')
print(unique_tournament_labels)

# Identify significant tournaments (appearing 100 or more times)
tournament_counts = results_df['tournament'].value_counts()
significant_tournaments = tournament_counts[tournament_counts >= 100].index

# Sort tournaments by their number of appearances
sorted_tournaments = tournament_counts[tournament_counts >= 100].sort_values(ascending=False).index

# Filter the results for significant tournaments and maintain the sorted order
significant_results_sorted = results_df[results_df['tournament'].isin(sorted_tournaments)].copy()
significant_results_sorted['tournament'] = pd.Categorical(significant_results_sorted['tournament'], categories=sorted_tournaments, ordered=True)

# Calculate average scores for home and away teams for each tournament type
average_scores_sorted = significant_results_sorted.groupby('tournament').agg(
    home_team_avg_score=('home_score', 'mean'),
    away_team_avg_score=('away_score', 'mean')
).reset_index()

# Plot the average scores for each tournament type with improved x-axis visualization
plt.figure(figsize=(18, 10))
average_scores_melted_sorted = average_scores_sorted.melt(id_vars='tournament', value_vars=['home_team_avg_score', 'away_team_avg_score'],
                                                          var_name='score_type', value_name='average_score')
sns.barplot(data=average_scores_melted_sorted, x='tournament', y='average_score', hue='score_type', palette=['blue', 'orange'])
plt.title('Average Scores for Home and Away Teams in Significant Tournaments')
plt.xlabel('Tournament Type')
plt.ylabel('Average Score')
plt.legend(title='Team')
plt.xticks(rotation=90)
plt.show()

significant_tournaments_count = significant_tournaments.shape[0]
print("Number of significant tournaments:", significant_tournaments_count)

# Convert date columns to datetime for proper merging
results_df['date'] = pd.to_datetime(results_df['date'])

# Calculate total matches won by home teams
home_wins = results_df[results_df['home_score'] > results_df['away_score']].groupby(['tournament', 'home_team']).size().reset_index(name='total_matches_won')
home_wins = home_wins.rename(columns={'home_team': 'team'})

# Calculate total matches won by away teams
away_wins = results_df[results_df['away_score'] > results_df['home_score']].groupby(['tournament', 'away_team']).size().reset_index(name='total_matches_won')
away_wins = away_wins.rename(columns={'away_team': 'team'})

# Combine home and away wins
winning_teams = pd.concat([home_wins, away_wins], ignore_index=True)
winning_teams = winning_teams.groupby(['tournament', 'team']).sum().reset_index()

# Get the top 10 significant tournaments
tournament_counts = results_df['tournament'].value_counts()
top_10_tournaments = tournament_counts.head(10).index

# Function to get the top winning teams for each tournament
def get_top_teams_by_tournament(winning_teams, tournament_name):
    tournament_matches = winning_teams[winning_teams['tournament'] == tournament_name]
    sorted_matches = tournament_matches.sort_values(by='total_matches_won', ascending=False)
    return sorted_matches.head(10)

# Create subplots
num_cols = 2
num_rows = (len(top_10_tournaments) + 1) // num_cols
fig, axes = plt.subplots(num_rows, num_cols, figsize=(20, 30))
axes = axes.flatten()

# Plot the team that won the most matches in each tournament
for idx, cup in enumerate(top_10_tournaments):
    ax = axes[idx]
    cup_data = get_top_teams_by_tournament(winning_teams, cup)
    sns.barplot(ax=ax, x='total_matches_won', y='team', data=cup_data, palette='Spectral')
    ax.set_title(cup, fontsize=14)
    ax.set_xlabel('Total Matches Won', fontsize=12)
    ax.set_ylabel('Team', fontsize=12)
    ax.tick_params(axis='x', labelsize=10, rotation=45)
    ax.tick_params(axis='y', labelsize=10)

# Adjust layout
plt.tight_layout()
plt.suptitle("Teams Winning Most Matches in Top 10 Significant Tournaments", y=1.02, fontsize=16)
plt.show()

# Count matches played by each team (home + away)
team_counts = results_df.assign(team=results_df['home_team']).groupby('team').size() + results_df.assign(team=results_df['away_team']).groupby('team').size()

# Get top 50 teams
top_teams = team_counts.nlargest(50).index

# Initialize a dictionary to hold data
top_teams_tournaments = {}

# For each top team, get their most played tournaments
for team in top_teams:
    home_tournaments = results_df.loc[results_df['home_team'] == team, 'tournament'].value_counts()
    away_tournaments = results_df.loc[results_df['away_team'] == team, 'tournament'].value_counts()
    all_tournaments = home_tournaments.add(away_tournaments, fill_value=0)
    top_tournaments = all_tournaments.nlargest(5)
    top_teams_tournaments[team] = top_tournaments

# Convert the dictionary into a DataFrame
top_teams_tournaments_df = pd.DataFrame(top_teams_tournaments)
top_teams_tournaments_df.fillna(0, inplace=True)

# Plot top 50 teams and their top 5 most played tournaments
top_teams_tournaments_df.T.plot(kind='bar', stacked=True, figsize=(20,10))

plt.title('Top 50 Teams and Their Top 5 Most Played Tournaments')
plt.xlabel('Teams')
plt.ylabel('Number of matches')
plt.legend(title='Tournaments', bbox_to_anchor=(1.05, 1), loc='upper left')
plt.tight_layout()
plt.show()

results_data.head(500)

# Create a figure with two subplots side by side
fig, axes = plt.subplots(1, 2, figsize=(20, 6), sharey=True)

# Plot the histogram for home_team_winrate
sns.histplot(data=results_data[(results_data['home_team_won'] == True) & 
                               (results_data['home_team_winrate'] >= 0) & 
                               (results_data['home_team_winrate'] <= 1)], 
             x="home_team_winrate", color='blue', label='Home Team Won', kde=True, ax=axes[0])

sns.histplot(data=results_data[(results_data['home_team_won'] == False) & 
                               (results_data['home_team_winrate'] >= 0) & 
                               (results_data['home_team_winrate'] <= 1)], 
             x="home_team_winrate", color='red', label='Home Team Lost', kde=True, ax=axes[0])

# Add titles and labels for the first subplot
axes[0].set_title('Distribution of Home Team Winrates')
axes[0].set_xlabel('Home Team Win Rate')
axes[0].set_ylabel('Count')
axes[0].set_xlim([0, 1])
axes[0].legend()

# Plot the histogram for away_team_winrate
sns.histplot(data=results_data[(results_data['home_team_won'] == False) & 
                               (results_data['away_team_winrate'] >= 0) & 
                               (results_data['away_team_winrate'] <= 1)], 
             x="away_team_winrate", color='red', label='Home Team Lost', kde=True, ax=axes[1])

sns.histplot(data=results_data[(results_data['home_team_won'] == True) & 
                               (results_data['away_team_winrate'] >= 0) & 
                               (results_data['away_team_winrate'] <= 1)], 
             x="away_team_winrate", color='blue', label='Home Team Won', kde=True, ax=axes[1])

# Add titles and labels for the second subplot
axes[1].set_title('Distribution of Away Team Winrates When Home Team Loses')
axes[1].set_xlabel('Away Team Win Rate')
axes[1].set_xlim([0, 1])
axes[1].legend()

# Show the plots
plt.tight_layout()
plt.show()

# Sort results_data by date
results_data_sorted = results_data.sort_values('date')

# Create a DataFrame for cumulative goals and matches
home_teams = results_data_sorted[['date', 'home_team', 'home_score']].rename(columns={'home_team': 'team', 'home_score': 'goals'})
away_teams = results_data_sorted[['date', 'away_team', 'away_score']].rename(columns={'away_team': 'team', 'away_score': 'goals'})

# Combine home and away data into one DataFrame
teams = pd.concat([home_teams, away_teams]).sort_values('date').reset_index(drop=True)

# Calculate cumulative goals and matches for each team
teams['cumulative_goals'] = teams.groupby('team')['goals'].cumsum().shift(fill_value=0)
teams['cumulative_matches'] = teams.groupby('team').cumcount().shift(fill_value=0) + 1

# Calculate average goals
teams['average_goals'] = teams['cumulative_goals'] / teams['cumulative_matches']
teams['average_goals'].fillna(0, inplace=True)

# Ensure no duplicate index values are present
teams.reset_index(drop=True, inplace=True)

# Find the team with the highest average goals
max_average_goals = teams.loc[teams['average_goals'].idxmax()]

# Merge the calculated averages back to the original DataFrame
results_data_sorted = results_data_sorted.merge(
    teams[['date', 'team', 'average_goals']].rename(columns={'team': 'home_team', 'average_goals': 'home_team_averagegoals'}),
    on=['date', 'home_team'],
    how='left'
)

results_data_sorted = results_data_sorted.merge(
    teams[['date', 'team', 'average_goals']].rename(columns={'team': 'away_team', 'average_goals': 'away_team_averagegoals'}),
    on=['date', 'away_team'],
    how='left'
)

# Replace NA values with 0
results_data_sorted['home_team_averagegoals'].fillna(0, inplace=True)
results_data_sorted['away_team_averagegoals'].fillna(0, inplace=True)

# Put the new features from results_data_sorted to the original results_data
results_data['home_team_averagegoals'] = results_data_sorted['home_team_averagegoals']
results_data['away_team_averagegoals'] = results_data_sorted['away_team_averagegoals']


# Display the team with the highest average goals
print("Team with the highest average goals:")
print(max_average_goals)

results_data.head(1500)

# Create a figure with two subplots side by side
fig, axes = plt.subplots(1, 2, figsize=(20, 8))

# Define a palette to ensure that colors will be
# shared across the subplots
palette = {True: "#FA5858", False: "#58FA82"}

# Plot boxplots for home_team_averagegoals and whether the home team won
sns.boxplot(x="home_team_won", y="home_team_averagegoals", 
            data=results_data, palette=palette, ax=axes[0])
sns.stripplot(x="home_team_won", y="home_team_averagegoals", 
              data=results_data, color=".3", ax=axes[0])

# Add titles and labels for the first subplot
axes[0].set_title('Home Team Average Goals vs Home Team Wins')
axes[0].set_xlabel('Home Team Won')
axes[0].set_ylabel('Home Team Average Goals')

# Plot boxplots for away_team_averagegoals and whether the home team won 
sns.boxplot(x="home_team_won", y="away_team_averagegoals",
            data=results_data, palette=palette, ax=axes[1])
sns.stripplot(x="home_team_won", y="away_team_averagegoals",
              data=results_data, color=".3", ax=axes[1])

# Add titles and labels for the second subplot
axes[1].set_title('Away Team Average Goals vs Home Team Wins')
axes[1].set_xlabel('Home Team Won')
axes[1].set_ylabel('Away Team Average Goals')

plt.show()

results_data.head(1500)

# Import the necessary libraries for plotting
import matplotlib.pyplot as plt
import seaborn as sns

# Create a figure with two subplots side by side
fig, axes = plt.subplots(1, 2, figsize=(30, 10))

# Define a palette to ensure that colors will be
# shared across the subplots
palette = {True: "#FA5858", False: "#58FA82"}

# Plot boxplots for 'head_to_head_win_ratio' vs Home Team Won
sns.boxplot(x='home_team_won', y='head_to_head_win_ratio', data=results_data, palette=palette, ax=axes[0])
sns.stripplot(x='home_team_won', y='head_to_head_win_ratio', data=results_data, color=".3", ax=axes[0])

axes[0].set_title('Head-to-Head Win Ratio vs Home Team Winning')
axes[0].set_xlabel('Home Team Won')
axes[0].set_ylabel('Head-to-Head Win Ratio')

# Plot boxplots for 'head_to_head_goal_diff' vs Home Team Won
sns.boxplot(x='home_team_won', y='head_to_head_goal_diff', data=results_data, palette=palette, ax=axes[1])
sns.stripplot(x='home_team_won', y='head_to_head_goal_diff', data=results_data, color=".3", ax=axes[1])

axes[1].set_title('Head-to-Head Goal Difference vs Home Team Winning')
axes[1].set_xlabel('Home Team Won')
axes[1].set_ylabel('Head-to-Head Goal Difference')

plt.show()

results_data.head(1500)

# Create a figure with two subplots 
fig, axes = plt.subplots(1, 2, figsize=(20, 10))

# plot boxplot for home_recent_performance
sns.boxplot(x='home_team_won', y='home_recent_performance', data=results_data, ax=axes[0])
axes[0].set_title('Home Team Recent Performance vs Win/Loss')

# plot boxplot for away_recent_performance
sns.boxplot(x='home_team_won', y='away_recent_performance', data=results_data, ax=axes[1])
axes[1].set_title('Away Team Recent Performance vs Win/Loss')

plt.tight_layout()
plt.show()

# Add a unique identifier for each match if not already present
if 'match_id' not in results_data.columns:
    results_data['match_id'] = range(1, len(results_data) + 1)

# Ensure date columns are in datetime format
results_data['date'] = pd.to_datetime(results_data['date'])

def calculate_tournament_experience(df):
    '''Function to compute the tournament experience and ratio'''
    tournament_exp = pd.concat([
        df[['date', 'home_team', 'tournament', 'match_id']].rename(columns={'home_team': 'team'}),
        df[['date', 'away_team', 'tournament', 'match_id']].rename(columns={'away_team': 'team'})
    ])
    tournament_exp.sort_values('date', inplace=True)
    tournament_exp['experience'] = tournament_exp.groupby(['team', 'tournament']).cumcount()

    home_exp = df.merge(
        tournament_exp.rename(columns={'team': 'home_team', 'experience': 'home_experience'}),
        on=['date', 'home_team', 'tournament', 'match_id'],
        how='left'
    )
    exp_with_away = home_exp.merge(
        tournament_exp.rename(columns={'team': 'away_team', 'experience': 'away_experience'}),
        on=['date', 'away_team', 'tournament', 'match_id'],
        how='left'
    )
    
    # Ensure 'away_experience' is not zero to avoid division by zero
    exp_with_away['away_experience'] = exp_with_away['away_experience'].replace(0, 1)
    
    exp_with_away['tournament_experience_ratio'] = exp_with_away['home_experience'] / exp_with_away['away_experience']
    
    # Replace inf values with max non-inf ratio
    max_ratio = exp_with_away[exp_with_away['tournament_experience_ratio'] != np.inf]['tournament_experience_ratio'].max()
    exp_with_away['tournament_experience_ratio'].replace(np.inf, max_ratio, inplace=True)
    
    # Replace NA values with 1
    exp_with_away['tournament_experience_ratio'].fillna(1, inplace=True)
    
    return exp_with_away[['match_id', 'home_experience', 'away_experience', 'tournament_experience_ratio']]

# Calculate tournament experience and ratio
tournament_experience = calculate_tournament_experience(results_data)

# Merge the calculated result back to the original DataFrame using 'match_id' to avoid duplicates
results_data = results_data.drop(columns=['home_experience', 'away_experience', 'tournament_experience_ratio'], errors='ignore')
results_data = results_data.merge(
    tournament_experience, on='match_id', how='left'
)

# Check for duplicates after merging
duplicates = results_data.duplicated(subset=['match_id']).sum()
print(f"Number of duplicate rows after merge: {duplicates}")

# Create a figure and plot
plt.figure(figsize=(10, 5))

# Plot distribution of 'tournament_experience_ratio' when home team won
sns.kdeplot(data=results_data[(results_data['home_team_won'] == 1) & 
                               (results_data['tournament_experience_ratio'] >= 0) & 
                               (results_data['tournament_experience_ratio'] <= 10)], 
            x='tournament_experience_ratio', color='blue', label='Home Team Won',
            fill=True)

# Plot distribution of 'tournament_experience_ratio' when home team lost
sns.kdeplot(data=results_data[(results_data['home_team_won'] == 0) & 
                               (results_data['tournament_experience_ratio'] >= 0) & 
                               (results_data['tournament_experience_ratio'] <= 10)], 
            x='tournament_experience_ratio', color='red', label='Home Team Lost',
            fill=True)

plt.title('Distribution of Tournament Experience Ratio for Home Team Wins/Losses')
plt.xlabel('Tournament Experience Ratio')
plt.ylabel('Density')
plt.xlim([0, 10])  # Limit x-axis between 0 and 10
plt.legend()
plt.show()

import pandas as pd
import numpy as np
from scipy.stats import pointbiserialr
import matplotlib.pyplot as plt
import seaborn as sns

# Create a copy of the DataFrame
results_data_copy = results_data.copy()

# Convert target variable to binary (0 and 1)
results_data_copy['home_team_won'] = results_data_copy['home_team_won'].astype(int)

# Calculate point-biserial correlation for all numeric features with the target
correlations = {}
for column in results_data_copy.columns:
    if column != 'home_team_won':
        if np.issubdtype(results_data_copy[column].dtype, np.number):
            corr, _ = pointbiserialr(results_data_copy['home_team_won'], results_data_copy[column])
            correlations[column] = corr

# Convert to DataFrame for better visualization
corr_df = pd.DataFrame.from_dict(correlations, orient='index', columns=['Correlation'])

# Plotting
plt.figure(figsize=(10, 6))
sns.barplot(x=corr_df.index, y=corr_df['Correlation'])
plt.title('Correlation between Features and Home Team Winning')
plt.xticks(rotation=45, ha='right')
plt.xlabel('Features')
plt.ylabel('Point-Biserial Correlation')
plt.tight_layout()
plt.show()

results_data.head()

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import AdaBoostClassifier
from sklearn.metrics import accuracy_score, confusion_matrix, classification_report
import matplotlib.pyplot as plt
import seaborn as sns

# relevant features for model training
features = [
    'home_team_winrate', 'away_team_winrate',
    'head_to_head_goal_diff', 'home_recent_performance', 'away_recent_performance','hometeam_total_goals','awayteam_total_goals',
    'tournament_experience_ratio', 'head_to_head_win_ratio','neutral','home_team_elo','away_team_elo'
]
X = results_data[features]
y = results_data['home_team_won']

# Output the shapes of the features and labels
X.shape, y.shape

# Check feature correlations
correlation_matrix = results_data[features].corr()
plt.figure(figsize=(12, 8))
sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm')
plt.title('Feature Correlation Matrix')
plt.show()

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split, cross_val_score, GridSearchCV
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier, GradientBoostingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, f1_score
import matplotlib.pyplot as plt
import seaborn as sns

# Use the entire dataset
X = results_data[features]
y = results_data['home_team_won']

# Define parameter grids
rf_param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [None, 10, 20, 30],
    'min_samples_split': [2, 5, 10]
}
lr_param_grid = {
    'C': [0.01, 0.1, 1, 10, 100]
}
ada_param_grid = {
    'n_estimators': [50, 100, 200],
    'learning_rate': [0.01, 0.1, 1, 10]
}
gb_param_grid = {
    'n_estimators': [50, 100, 200],
    'learning_rate': [0.01, 0.1, 0.2],
    'max_depth': [3, 4, 5]
}

# Initialize GridSearchCV for each model
rf_grid_search = GridSearchCV(RandomForestClassifier(random_state=42), rf_param_grid, cv=5, scoring='accuracy')
lr_grid_search = GridSearchCV(LogisticRegression(max_iter=1000, random_state=42), lr_param_grid, cv=5, scoring='accuracy')
ada_grid_search = GridSearchCV(AdaBoostClassifier(random_state=42), ada_param_grid, cv=5, scoring='accuracy')
gb_grid_search = GridSearchCV(GradientBoostingClassifier(random_state=42), gb_param_grid, cv=5, scoring='accuracy')

# Fit the GridSearchCV models
rf_grid_search.fit(X, y)
lr_grid_search.fit(X, y)
ada_grid_search.fit(X, y)
gb_grid_search.fit(X, y)

# Print the best parameters
print("Best parameters for Random Forest:", rf_grid_search.best_params_)
print("Best parameters for Logistic Regression:", lr_grid_search.best_params_)
print("Best parameters for AdaBoost:", ada_grid_search.best_params_)
print("Best parameters for Gradient Boosting:", gb_grid_search.best_params_)

# Get the best models
best_rf_model = rf_grid_search.best_estimator_
best_lr_model = lr_grid_search.best_estimator_
best_ada_model = ada_grid_search.best_estimator_
best_gb_model = gb_grid_search.best_estimator_

# Perform cross-validation with the best models for accuracy and F1 score
best_rf_cv_scores = cross_val_score(best_rf_model, X, y, cv=5, scoring='accuracy')
best_rf_f1_scores = cross_val_score(best_rf_model, X, y, cv=5, scoring='f1')

best_lr_cv_scores = cross_val_score(best_lr_model, X, y, cv=5, scoring='accuracy')
best_lr_f1_scores = cross_val_score(best_lr_model, X, y, cv=5, scoring='f1')

best_ada_cv_scores = cross_val_score(best_ada_model, X, y, cv=5, scoring='accuracy')
best_ada_f1_scores = cross_val_score(best_ada_model, X, y, cv=5, scoring='f1')

best_gb_cv_scores = cross_val_score(best_gb_model, X, y, cv=5, scoring='accuracy')
best_gb_f1_scores = cross_val_score(best_gb_model, X, y, cv=5, scoring='f1')

# Calculate the mean and standard deviation of the cross-validation scores
best_rf_mean_accuracy = np.mean(best_rf_cv_scores)
best_rf_std_accuracy = np.std(best_rf_cv_scores)
best_rf_mean_f1 = np.mean(best_rf_f1_scores)
best_rf_std_f1 = np.std(best_rf_f1_scores)

best_lr_mean_accuracy = np.mean(best_lr_cv_scores)
best_lr_std_accuracy = np.std(best_lr_cv_scores)
best_lr_mean_f1 = np.mean(best_lr_f1_scores)
best_lr_std_f1 = np.std(best_lr_f1_scores)

best_ada_mean_accuracy = np.mean(best_ada_cv_scores)
best_ada_std_accuracy = np.std(best_ada_cv_scores)
best_ada_mean_f1 = np.mean(best_ada_f1_scores)
best_ada_std_f1 = np.std(best_ada_f1_scores)

best_gb_mean_accuracy = np.mean(best_gb_cv_scores)
best_gb_std_accuracy = np.std(best_gb_cv_scores)
best_gb_mean_f1 = np.mean(best_gb_f1_scores)
best_gb_std_f1 = np.std(best_gb_f1_scores)

# Print the results in an organized manner
print(f"{'Model':<20} {'Accuracy Mean':<20} {'Accuracy Std':<20} {'F1-Score Mean':<20} {'F1-Score Std':<20}")
print("="*100)
print(f"{'Random Forest':<20} {best_rf_mean_accuracy:<20.4f} {best_rf_std_accuracy:<20.4f} {best_rf_mean_f1:<20.4f} {best_rf_std_f1:<20.4f}")
print(f"{'Logistic Regression':<20} {best_lr_mean_accuracy:<20.4f} {best_lr_std_accuracy:<20.4f} {best_lr_mean_f1:<20.4f} {best_lr_std_f1:<20.4f}")
print(f"{'AdaBoost':<20} {best_ada_mean_accuracy:<20.4f} {best_ada_std_accuracy:<20.4f} {best_ada_mean_f1:<20.4f} {best_ada_std_f1:<20.4f}")
print(f"{'Gradient Boosting':<20} {best_gb_mean_accuracy:<20.4f} {best_gb_std_accuracy:<20.4f} {best_gb_mean_f1:<20.4f} {best_gb_std_f1:<20.4f}")

# Plot the results
models = ['Random Forest', 'Logistic Regression', 'AdaBoost', 'Gradient Boosting']
mean_accuracies = [best_rf_mean_accuracy, best_lr_mean_accuracy, best_ada_mean_accuracy, best_gb_mean_accuracy]
std_accuracies = [best_rf_std_accuracy, best_lr_std_accuracy, best_ada_std_accuracy, best_gb_std_accuracy]
mean_f1_scores = [best_rf_mean_f1, best_lr_mean_f1, best_ada_mean_f1, best_gb_mean_f1]
std_f1_scores = [best_rf_std_f1, best_lr_std_f1, best_ada_std_f1, best_gb_std_f1]

fig, ax = plt.subplots(2, 1, figsize=(10, 12))

ax[0].barh(models, mean_accuracies, xerr=std_accuracies, color='skyblue', edgecolor='black', capsize=5)
ax[0].set_xlabel('Accuracy')
ax[0].set_title('Model Comparison with Cross-Validation Accuracy')
ax[0].grid(True, linestyle='--', alpha=0.6)

ax[1].barh(models, mean_f1_scores, xerr=std_f1_scores, color='lightgreen', edgecolor='black', capsize=5)
ax[1].set_xlabel('F1 Score')
ax[1].set_title('Model Comparison with Cross-Validation F1 Scores')
ax[1].grid(True, linestyle='--', alpha=0.6)

plt.tight_layout()
plt.show()

# Plot feature importance for each model
def plot_feature_importance(model, model_name):
    model.fit(X, y)
    importances = model.feature_importances_ if hasattr(model, 'feature_importances_') else np.abs(model.coef_[0])
    feature_importance_df = pd.DataFrame({'feature': features, 'importance': importances})
    feature_importance_df = feature_importance_df.sort_values(by='importance', ascending=False)

    plt.figure(figsize=(10, 6))
    sns.barplot(x='importance', y='feature', data=feature_importance_df)
    plt.title(f'Feature Importance for {model_name}')
    plt.show()

plot_feature_importance(best_rf_model, 'Random Forest')
plot_feature_importance(best_lr_model, 'Logistic Regression')
plot_feature_importance(best_ada_model, 'AdaBoost')
plot_feature_importance(best_gb_model, 'Gradient Boosting')

# Calculate the best players
goalscorers_data['goal_count'] = 1
best_players = goalscorers_data.groupby(['team', 'scorer'])['goal_count'].sum().reset_index()
best_players = best_players.loc[best_players.groupby('team')['goal_count'].idxmax()][['team', 'scorer']]
best_players.set_index('team', inplace=True)

# Initialize a list to accumulate rows
team_stats_list = []

teams = pd.concat([results_data['home_team'], results_data['away_team']]).unique()

for team in teams:
    team_data_home = results_data[results_data['home_team'] == team]
    team_data_away = results_data[results_data['away_team'] == team]
    team_data = pd.concat([team_data_home, team_data_away])

    total_matches = len(team_data)
    total_wins = team_data_home['home_team_won'].sum() + team_data_away['away_team_won'].sum()
    total_goals = team_data_home['home_score'].sum() + team_data_away['away_score'].sum()

    winrate = total_wins / total_matches if total_matches > 0 else 0
    average_goals = total_goals / total_matches if total_matches > 0 else 0

    most_played_tournament = team_data['tournament'].value_counts().idxmax()

    best_player = best_players.loc[team, 'scorer'] if team in best_players.index else 'NA'

    # Calculate average ELO
    total_elo = team_data_home['home_team_elo'].sum() + team_data_away['away_team_elo'].sum()
    average_elo = total_elo / total_matches if total_matches > 0 else 0

    team_stats_list.append({
        "team": team, "total_wins": total_wins, "total_goals": total_goals,
        "total_matches": total_matches, "winrate": winrate,
        "average_goals": average_goals, "most_played_tournament": most_played_tournament,
        "best_player": best_player, "average_elo": average_elo
    })

# Convert the list to a DataFrame
team_stats = pd.DataFrame(team_stats_list)
team_stats.set_index('team', inplace=True)

# Checking if the 'team' column is in the index
print(team_stats.index.name)